home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / netzwerk / tcp-ip / ipdial_v1.9 / debug / DeviceIO.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-14  |  4.4 KB  |  205 lines
  1. /**
  2. ***  IPDial     Script program for initializing a SLIP connection
  3. ***  Copyright  (C)   1994    Jochen Wiedmann
  4. ***
  5. ***  This program is free software; you can redistribute it and/or modify
  6. ***  it under the terms of the GNU General Public License as published by
  7. ***  the Free Software Foundation; either version 2 of the License, or
  8. ***  (at your option) any later version.
  9. ***
  10. ***  This program is distributed in the hope that it will be useful,
  11. ***  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ***  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ***  GNU General Public License for more details.
  14. ***
  15. ***  You should have received a copy of the GNU General Public License
  16. ***  along with this program; if not, write to the Free Software
  17. ***  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. ***
  19. ***
  20. ***
  21. ***  This file implements something like a device class. It's only
  22. ***  reason is the lack of a possibility to determine the real state
  23. ***  of an IORequest. (Sent? Inactive? Whatever else?)
  24. ***
  25. ***
  26. ***  Computer: Amiga 1200                       Compiler: Dice 3.01
  27. ***
  28. ***  Author:    Jochen Wiedmann
  29. ***             Am Eisteich 9
  30. ***             72555 Metzingen
  31. ***             Germany
  32. ***
  33. ***             Phone: (+0049) 7123 / 14881
  34. ***             Internet: wiedmann@neckar-alb.de
  35. **/
  36.  
  37. /**
  38. ***  Include files
  39. **/
  40. #ifndef IPDIAL_H
  41. #include "IPDial.h"
  42. #endif
  43. #include <exec/devices.h>
  44. #include <exec/io.h>
  45. /**
  46. ***  We use the structure below for device IO, because I don't see
  47. ***  any way to check an IORequest whether it must be aborted, before
  48. ***  using or deleting it.
  49. **/
  50. struct MyIORequest
  51. { 
  52.   ULONG Used;
  53.   ULONG Signal;
  54.   ULONG DeviceOpen;
  55.   struct IORequest *Req;
  56. };
  57. /**
  58. ***  This is the WaitIO() equivalent.
  59. **/
  60. BYTE DeviceIOWait(APTR wreq)
  61. { 
  62.   struct MyIORequest *req = wreq;
  63.   BYTE result;
  64.  
  65.   result = WaitIO(req->Req);
  66.   req->Used = FALSE;
  67.   return(result);
  68. }
  69. /**
  70. ***  This is the AbortIO() equivalent.
  71. **/
  72. VOID DeviceIOAbort(APTR areq)
  73. { struct MyIORequest *req = areq;
  74.  
  75.   if (req  &&  req->Used  &&  req->Req)
  76.   { 
  77.     AbortIO(req->Req);
  78.     DeviceIOWait(req);
  79.   }
  80.   /**
  81.   ***  The following is needed for reasons I don't understand
  82.   ***  really.
  83.   **/
  84.   SetSignal(0, req->Signal);
  85. }
  86. /**
  87. ***  This is the SendIO() equivalent.
  88. **/
  89. VOID DeviceIOSend(APTR sreq, UWORD Command)
  90. { 
  91.   struct MyIORequest *req = sreq;
  92.  
  93.   if (req->Used)
  94.   { 
  95.     fprintf(stderr, "Internal error: IORequest in use.\n");
  96.     exit(20);
  97.   }
  98.   req->Used = TRUE;
  99.   req->Req->io_Command = Command;
  100.   SendIO(req->Req);
  101. }
  102. /**
  103. ***  This is the DoIO() equivalent.
  104. **/
  105. BYTE DeviceIODo(APTR dreq, UWORD Command)
  106. {
  107.   BYTE   status; 
  108.   struct MyIORequest *req = dreq;
  109.  
  110.   if (req->Used)
  111.   { 
  112.     fprintf(stderr, "Internal error: IORequest in use.\n");
  113.     exit(20);
  114.   }
  115.   req->Req->io_Command = Command;
  116.   status = DoIO(req->Req);
  117.   Delay(10);
  118.   return(status);
  119. }
  120. /**
  121. ***  This is the DeleteIORequest() equivalent.
  122. **/
  123. VOID DeviceIODelete(APTR dreq)
  124. { 
  125.   struct MyIORequest *req = dreq;
  126.  
  127.   if (req)
  128.   { 
  129.     DeviceIOAbort(req);
  130.     if (req->DeviceOpen)
  131.     { 
  132.       CloseDevice(req->Req);
  133.     }
  134.     if (req->Req)
  135.     { 
  136.       struct MsgPort *port = req->Req->io_Message.mn_ReplyPort;
  137.  
  138.       DeleteIORequest(req->Req);
  139.       DeleteMsgPort(port);
  140.     }
  141.     free(req);
  142.   }
  143. }
  144. /**
  145. ***  This is the CreateIORequest() equivalent.
  146. **/
  147. APTR DeviceIOCreate(ULONG Size)
  148. { 
  149.   struct MyIORequest *req;
  150.  
  151.   if ((req = malloc(sizeof(*req))))
  152.   { 
  153.     struct MsgPort *port;
  154.  
  155.     req->Used = FALSE;
  156.     req->DeviceOpen = FALSE;
  157.     if ((port = CreateMsgPort()))
  158.     { 
  159.       req->Signal = (1 << port->mp_SigBit);
  160.       if ((req->Req = CreateIORequest(port, Size)))
  161.       { 
  162.         return(req);
  163.       }
  164.       DeleteMsgPort(port);
  165.     }
  166.     free(req);
  167.   }
  168.   return(NULL);
  169. }
  170. /**
  171. ***  This is the OpenDevice() equivalent.
  172. **/
  173. BYTE DeviceIOOpen(STRPTR devname, ULONG unit, APTR oreq, ULONG flags)
  174. { 
  175.   struct MyIORequest *req = oreq;
  176.   BYTE error;
  177.  
  178.   if (req->DeviceOpen)
  179.   { 
  180.     fprintf(stderr, "Internal error: Device already open.\n");
  181.     exit(20);
  182.   }
  183.   if (!(error = OpenDevice(devname, unit, req->Req, flags)))
  184.   { 
  185.     req->DeviceOpen = TRUE;
  186.   }
  187.   return(error);
  188. }
  189. /**
  190. ***  This function returns the IORequest attached to a struct
  191. ***  MyIORequest.
  192. **/
  193. struct IORequest *DeviceIOReq(APTR rreq)
  194. { 
  195.   return(((struct MyIORequest *)rreq)->Req);
  196. }
  197. /**
  198. ***  This function returns an IORequest's signal. (Not the
  199. ***  signal number.)
  200. **/
  201. ULONG DeviceIOSignal(APTR sreq)
  202. { 
  203.   return(((struct MyIORequest *) sreq)->Signal);
  204. }
  205.